句子|语料_快速构建一个简单的对话+问答AI（上）

篇首语：本文由编程笔记#小编为大家整理，主要介绍了快速构建一个简单的对话+问答AI （上）相关的知识，希望对你有一定的参考价值。

文章目录

• 前言
• part0 资源准备
• • 基本功能
  • 语料
  • • 停用词
    • 问答
    • 闲聊语料
    
    
  • 获取
  
  
• part01句的表达
• • 表达
  • • one-hot编码
    
    
  • 词嵌入
  • • • 大致原理
      • 实现
      • • 简单版
        • 复杂版
        • • 如何训练
          
          
        
        
      
      
    • 转换后的形状
    
    
  
  
• part02 循环神经网络
• • RNN
  • • RNN投影图
    • RNN是三维立体的
    
    
  • LSTM&GRU
  
  
• part03意图识别
• • 分词
  • FastText分类
  • • FastText网络结构
    • 优化点
    
    
  • 构造FastText数据集
  • 训练
  
  
• part04 闲聊对话
• • Seq2Seq
  • • 网络结构
    • 输入与输出&＃xff08;编/解码器&＃xff09;
    
    
  • 数据准备
  • • 构造词典
    • 数据加载
    
    
  • 网络搭建
  • • 编码器
    • 解码器
    • 注意力机制
    
    
  • 训练
  • • 搭建seq网络
    • 训练
    
    
  • 推理
  • • BeamSearch
    • 完整过程
    
    
  
  
• Part05 问答处理
• • 简单思路
  • 难点
  
  
• 上文分割线

okey,许久不见甚是想念&＃xff0c;那么今天的话也是来开启一个新的一个章节吧。当然承认最近是有在划水&＃xff0c;但是问题不大。那么今天的话咱们就是来填一填以前的坑&＃xff0c;吹过的牛皮总还是要实现的。那么在这边咱们的目的是实现出一个简单一点的AI助手&＃xff0c;通过我们的文本来实现一些对话&＃xff0c;问答之类的一些处理。从基础部分&＃xff0c;一步一步实现一个这样的小AI&＃xff0c;在未来你还可以打造属于自己的一个数据集&＃xff0c;同时在这个架构的基础上不断优化&＃xff0c;在未来的某一天也许是有机会得到一个专属于你的一个AI对象的。

所以咱们今天给出的还是一个baseline。同时本文的风格也是慢慢来递进的&＃xff0c;从最基础的尺度表达&＃xff0c;到搭建一个网络&＃xff0c;再到基本的优化&＃xff0c;最后是一个封装。
项目开源地址&＃xff1a;
https://github.com/Huterox/xiaojiejieBoot.git

咱们的这个机器人就叫叫作“小姐姐”。是的非常的直接&＃xff1a;Although I have been rejected, I will not give up.
对应语料资源&＃xff1a;
https://github.com/codemayq/chinese_chatbot_corpus

基本要求&＃xff0c;阅读本篇文章需要一定的门槛&＃xff1a;

• 熟练掌握python
• 了解基本的深度学习知识
• 会使用pytorch搭建神经网络
• 具备一定的抽象能力&＃xff08;受限于篇幅问题&＃xff0c;本博文在原理部分只能做简化&＃xff0c;因此重点还是实战&＃xff08;或者说&＃xff0c;都在代码里面了&＃xff09;&＃xff0c;但是对应相应内容都会进行一个介绍&＃xff0c;和我认为比较容易不太好理解的点&＃xff0c;所以如果想要完善理论部分的话&＃xff0c;建议自行深入&＃xff0c;这里更多是科普&＃xff0c;之后是代码实现&＃xff0c;你将这部分作为灰盒子就好了&＃xff0c;因为你还是可以调参&＃xff0c;准备自己的数据集的&＃xff09;

ok,在开始之前呢&＃xff0c;咱们先来说说在咱们本篇博文当中&＃xff0c;咱们是怎么设计的&＃xff0c;需要使用到哪些资源。

基本功能

先来看到咱们的这个基本功能的一个样例图吧&＃xff1a;

所以的话&＃xff0c;咱们这边有问答功能&＃xff0c;和闲聊功能&＃xff0c;现在的话&＃xff0c;那么闲聊的话其实顾名思义&＃xff0c;其实就是说如果你想要让这个AI能够就是说像情侣一样对话的话&＃xff0c;那么这个闲聊就是咱们的这个恋爱聊天功能&＃xff0c;也就是所谓的AI女友的最基本的一个对话雏形。

语料

ok,看到了咱们的一个具体的大致的功能&＃xff0c;那么咱们接下来要做的就是说&＃xff0c;我们需要使用到哪些东西。首先的话&＃xff0c;由于咱们只是先做一个baseline级别的dome&＃xff0c;加上咱们的这个算力确实比较那啥。所以的话&＃xff0c;咱们的这个语料都是做了一个简要的删减&＃xff0c;因为确实是太多了。
那么首先咱们这边使用的主要是这四个东西&＃xff1a;

首先第一个是百度问答的问答对一共是5W&＃xff0c;还有小黄鸡的一个语料库&＃xff0c;大概是50W条问答。
之后第百度停用词和汉语词库。大概就这几个。那么如果你是想要做AI情侣的话&＃xff0c;那么就需要把小黄鸡的一个语料库&＃xff0c;换成这个对应的恋爱对话的一个语料&＃xff08;你可以尝试把你和你对象的对话搞过来&＃xff0c;但是量得足够大&＃xff0c;那么咱们这边就不去搞这种&＃xff0c;一方面是我搞不到这个数据集&＃xff0c;也没有没有办法从自己身上收集&＃xff0c;另一方面确实不太合适&＃xff0c;但是方法我还是会说的&＃xff09;

之后的话&＃xff0c;咱们来看看一看咱们的这个格式&＃xff1a;

停用词

打开之后的话&＃xff0c;格式大概是这样的&＃xff1a;

词库的格式也是类似的。

问答

之后的是问答的一个语料&＃xff0c;这个是百度的一个问答&＃xff0c;通过数据处理之后的一个格式。这边整理好了。格式是这样的&＃xff1a;

问答对。

闲聊语料

这个闲聊也简单&＃xff0c;是这样的&＃xff1a;

E 是开始标志
M 对话

这个到时候怎么用&＃xff0c;咱们在后面再说。

获取

之后的话是咱们的一个资源的获取。
这块的资源的话都已经打包好了在这&＃xff1a;
链接&＃xff1a;https://pan.baidu.com/s/1Bb0sWcITQLrkibDqIT8Qvg
提取码&＃xff1a;6666

表达

计算机和我们人类是不一样的&＃xff0c;他只能进行基本的数字运算&＃xff0c;在咱们先前的图像处理当中&＃xff0c;图像的表达依然还是通过数值矩阵的&＃xff0c;但是一个句子或者单纯是如何表示的呢。所以为了能够让计算机可以处理到咱们的文本数据&＃xff0c;咱们需要对文本做一点点处理。

那么在这里是如何做的呢&＃xff0c;其实很简单&＃xff0c;既然计算机只能处理数字&＃xff0c;对数字进行运算&＃xff0c;那么我们只需要把我们的一个句子转化为一种向量就好了。那么这个是如何做的呢&＃xff1f;

其实非常简单。

看下面一组图就明白了&＃xff1a;

我们通过一个词典其实就可以完成一个向量的映射。

看到了吧&＃xff0c;我们这个时候我们只需要对一个句子进行分词&＃xff0c;之后将每一个词进行标号&＃xff0c;这样一来就可以实现把一个句子转化为一个向量。

one-hot编码

此时我们得到了一组序列&＃xff0c;但是这个序列的表达能力是在是太弱了&＃xff0c;只能表示出一个标号&＃xff0c;不能表示出其他的特点。或者说&＃xff0c;只有一个数字表示一个词语实在是太单调了&＃xff0c;1个词语也应该由一个序列组成。那么这个时候one-hot编码就出来了。他是这样做的&＃xff1a;

首先一个词&＃xff0c;一个字&＃xff0c;我们叫做token&＃xff0c;那么编码的很简单。其实就是这样&＃xff1a;

但是这样是有问题的&＃xff0c;那就是说&＃xff0c;我们虽然实现了一个词到向量的表示。但是这个表示方法显然是太大了&＃xff0c;假设有10000个词语&＃xff0c;那么按照这种方式进行标号的话&＃xff0c;那么1个词就是10000个维度。这样显然是不行的。所以这块需要优化一下。

词嵌入

这个原来解释起来稍微复杂一点。你只需要需要知道他们的本质其实就是这样的&＃xff1a;
词 ——> 向量空间1 ——> 向量空间2
现在向量空间1不合适&＃xff0c;所以我们要想办法能不能往空间2进行靠拢。

于是乎这里大概就有了两个方案&＃xff1a;

1&＃xff09;尝试将词向量映射到一个更低维的空间&＃xff1b;
2&＃xff09;同时保持词向量在该低维空间中具备语义相似性&＃xff0c;如此&＃xff0c;越相关的词&＃xff0c;它们的向量在这个低维空间里就能靠得越近。

对于第一个&＃xff0c;咱们可以参考原来咱们做协同过滤推荐dome的时候&＃xff0c;使用SVD矩阵分解来做。&＃xff08;关于这篇博文的话也是有优化的&＃xff0c;优化方案将在本篇博文中查看到&＃xff0c;先插个眼&＃xff09;

那么缺点的话也很明显嘛&＃xff0c;用咱们的这个方案&＃xff1a;

1&＃xff09;亲和矩阵的维度可能经常变&＃xff0c;因为总有新的单词加进来&＃xff0c;每加进来一次就要重新做SVD分解&＃xff0c;因此这个方法不太通用&＃xff1b;
2&＃xff09;亲和矩阵可能很稀疏&＃xff0c;因为很多单词并不会成对出现。

大致原理

ok,回到咱们的这个&＃xff08;这部分可以选择跳过&＃xff0c;知道这个玩意最后得到的是啥就好了&＃xff09;&＃xff0c;这个该怎么做&＃xff0c;首先的话&＃xff0c;实现这个东西&＃xff0c;大概是有两种方案去做&＃xff1a;Continuous Bag Of Words (CBOW)方法和n-gram方法。第一个方案的话&＃xff0c;这个比较复杂&＃xff0c;咱们这里就不介绍了。

咱们来说说第二个方案。

首先咱们来说说啥是N-gram&＃xff0c;首先原理的话也是比较复杂的&＃xff0c;具体参考这个&＃xff1a;https://blog.csdn.net/songbinxu/article/details/80209197

那么我们这边就是简单说一下这个在咱们这边N-gram实际是咋用的。

[cuted[i:i&＃43;2]for i in range(len(cuted))]


其实就是这个&＃xff0c;用代码表示&＃xff0c;cuted是一个分好词的句子。i&＃43;2表示跨越几个。

这样做的好处是&＃xff0c;通过N-gram可以考虑到词语之间的一个关系&＃xff0c;如果我们使用这个方案来实现一个词向量的话&＃xff0c;那么我们必然是可以能够实现&＃xff1a;“同时保持词向量在该低维空间中具备语义相似性&＃xff0c;如此&＃xff0c;越相关的词&＃xff0c;它们的向量在这个低维空间里就能靠得越近。”的。因为确实考虑到了之间的一个关系&＃xff0c;那么现在我们已经知道了大概N-garm是怎么样的了&＃xff0c;其实就是一种方式&＃xff0c;将一个句子相近的词语进行连接&＃xff0c;或者说是对句子进行一个切割&＃xff0c;上面那个只是一种方式只有&＃xff0c;这个我们在后面还会有说明&＃xff0c;总之它是非常好用的一种方式。

ok,知道了这个我们再来介绍几个名词&＃xff1a;

1.跳词模型
跳词模型&＃xff0c;它是通过文本中某个单词来推测前后几个单词。例如&＃xff0c;根据‘rabbit’来推断前后的单词可能为‘a’,‘is’,‘eating’,‘carrot’。在训练模型时我们在文本中选取若干连续的固定长度的单词序列&＃xff0c;把前后的一些单词作为输出&＃xff0c;中间的某个位置的单词作为输入。

2.连续词袋模型
连续词袋模型与跳词模型恰好相反&＃xff0c;它是根据文本序列中周围单词来预测中心词。在训练模型时&＃xff0c;把序列中周围单词作为输入&＃xff0c;中心词作为输出。

这个的话其实和我们的这个关系不大&＃xff0c;因为N-gram其实是句子–>词 的一种方式&＃xff0c;但是对我训练的时候的输入还是有帮助的&＃xff0c;因为这样输入的话&＃xff0c;我们是可以得到词在句子当中的一种关联关系的。

而embedding是词到one-hot然后one-hot到低纬向量的变化过程。

实现

ok,扯了那么多&＃xff0c;那么接下来看看我们如何实现这个东西。

我们需要一个词向量&＃xff0c;同时我们有很多词语&＃xff0c;因此我们将得到一个矩阵&＃xff0c;这个矩阵叫做embedding矩阵。

我们首先随机初始化embeddings矩阵&＃xff0c;构建一个简单的网络。初始化weights和biases&＃xff0c;计算隐藏层的输出。然后计算输出和target结果的交叉熵&＃xff0c;之后使用优化器完成一次反向传递&＃xff0c;更新可训练的参数&＃xff0c;包括embeddings变量。并且我们将词之间的相似度可以看作概率。

ok,我们直接看到代码&＃xff0c;那么咱们也是有两个版本的。简单版&＃xff0c;复杂版。

简单版

简单版本的话&＃xff0c;在pytorch当中有实现&＃xff1a;

embed&＃61;nn.Embedding(word_num,embedding_dim)


复杂版

那么我们显然是不满足这个的&＃xff0c;那么我们还有复杂版本。就是自己动手&＃xff0c;丰衣足食&＃xff01;
首先我们定义这个&＃xff1a;

class embedding(nn.Module):
def __init__(self,in_dim,embed_dim):
super().__init__()
self.embed&＃61;nn.Sequential(nn.Linear(in_dim,200),
nn.ReLU(),
nn.Linear(200,embed_dim),
nn.Sigmoid())
def forward(self,input):
b,c,_&＃61;input.shape
output&＃61;[]
for i in range(c):
out&＃61;self.embed(input[:,i])
output.append(out.detach().numpy())
return torch.tensor(np.array(output),dtype&＃61;torch.float32).permute(1,0,2)


很简单的一个结构。
那么我们输入是上面&＃xff0c;首先其实是我们one-hot编码的一个矩阵。
我们其实流程就是这样的&＃xff1a;词—&＃xff1e;one-hot—>embedding/svd

ok,那么我们的N-gram如何表示呢&＃xff0c;其实这个更多的还是在于对句子的分解上&＃xff0c;输入的句子的词向量如何表示的。

如何训练

如何训练的话&＃xff0c;首先还是要在one-hot处理的时候再加一个处理&＃xff0c;这个过程可能比较绕。就是说我们按照上面提到的词袋模型进行构造我们的数据&＃xff0c;我们举个例子吧。

现在有这样的一个文本&＃xff0c;分词之后&＃xff0c;词的个数是content_size。有num_word个词。

import torch
import re
import numpy as np

txt&＃61;[] #文本数据
with open(&＃39;peter_rabbit.txt&＃39;,encoding&＃61;&＃39;utf-8&＃39;) as f:
for line in f.readlines():
l&＃61;line.strip()
spilted_sentence&＃61;re.split(" |;|-|,|!|\\&＃39;",l)
for w in spilted_sentence:
if w !&＃61;&＃39;&＃39;:
txt.append(w.lower())
vol&＃61;list(set(txt)) #单词表
n&＃61;len(vol) #单词表单词数
vol_dict&＃61;dict(zip(vol,np.arange(n))) #单词索引
&＃39;&＃39;&＃39;
这里使用词袋模型
每次从文本中选取序列长度为9&＃xff0c;输入单词数为,8&＃xff0c;输出单词数为1&＃xff0c;
中心词位于序列中间位置。并且采用pytorch中的emdedding和自己设计embedding两种方法
词嵌入维度为100。
&＃39;&＃39;&＃39;
data&＃61;[]
label&＃61;[]

for i in range(content_size):
in_words&＃61;txt[i:i&＃43;4]
in_words.extend(txt[i&＃43;6:i&＃43;10])
out_word&＃61;txt[i&＃43;5]
in_one_hot&＃61;np.zeros((8,n))
out_one_hot&＃61;np.zeros((1,n))
out_one_hot[0,vol_dict[out_word]]&＃61;1
for j in range(8):
in_one_hot[j,vol_dict[in_words[j]]]&＃61;1
data.append(in_one_hot)
label.append(out_one_hot)

class dataset:
def __init__(self):
self.n&＃61;ci&＃61;config.content_size
def __len__(self):
return self.n
def __getitem__(self, item):
traindata&＃61;torch.tensor(np.array(data),dtype&＃61;torch.float32)
trainlabel&＃61;torch.tensor(np.array(label),dtype&＃61;torch.float32)
return traindata[item],trainlabel[item]


我们只是在投喂数据的时候按照词袋模型进行投喂&＃xff0c;或者连续模型也可以。

当然我们这里所说的都只是说预训练出一个模型出来&＃xff0c;实际上&＃xff0c;我们直接使用这个结构&＃xff0c;然后进行正常的训练完成我们的一个模型也是可以的。她是很灵活的&＃xff0c;不是固定的&＃xff01;

那么继续预训练的话就是按照词袋模型来就好了&＃xff08;看不懂没关系&＃xff0c;跳过就好了&＃xff09;

import torch
from torch import nn
from torch.utils.data import DataLoader
from dataset import dataset
import numpy as np
class model(nn.Module):
def __init__(self):
super().__init__()
self.embed&＃61;embedding(num_word,100)
self.fc1&＃61;nn.Linear(num_word,1000)
self.act1&＃61;nn.ReLU()
self.fc2&＃61;nn.Linear(1000,num_word)
self.act2&＃61;nn.Sigmoid()
def forward(self,input):
b,_,_&＃61;input.shape
out&＃61;self.embed (input).view(b,-1)
out&＃61;self.fc1 (out)
out&＃61;self.act1(out)
out&＃61;self.fc2(out)
out&＃61;self.act2(out)
out&＃61;out.view(b,1,-1)
return out
if __name__&＃61;&＃61;&＃39;__main__&＃39;:
pre_model&＃61;model()
optim&＃61;torch.optim.Adam(params&＃61;pre_model.parameters())
Loss&＃61;nn.MSELoss()
traindata&＃61;DataLoader(dataset(),batch_size&＃61;5,shuffle&＃61;True)
for i in range(100):
print(&＃39;the epoch&＃39;.format(i))
for d in traindata:
p&＃61;model(d[0])
loss&＃61;Loss(p,d[1])
optim.zero_grad()
loss.backward()
optim.step()


这样一来就可以初步完成预训练&＃xff0c;你只需要加载好embeding部分的权重就好了&＃xff0c;这个只是加快收敛的一种方式。

转换后的形状

最终&＃xff0c;词嵌入的话&＃xff0c;得到的矩阵是将one-hot变化为了这样的矩阵

ok,词的表达已经&＃x1f197;了&＃xff0c;那么接下来我们在简单介绍一下RNN。
&＃xff08;当然对于这一部分&＃xff0c;实际上的话其实还有别的方法&＃xff0c;但是咱们这边只是用到这些东西&＃xff0c;所以只是介绍这个&＃xff09;

RNN

这个RNN的话&＃xff0c;咋说呢&＃xff0c;其实挺简单的&＃xff0c;但是有几个点可能是比较容易误导人的&＃xff0c;搞清楚这个结构的话&＃xff0c;对于我们后面对于LSTM&＃xff0c;GRU这种网络的架构可能会更好了解&＃xff0c;其实包括LSTM&＃xff0c;GRU的话其实本质上还是挺简单的。当然能够直接提出这个东西的人是非常厉害的&＃xff0c;不过不管怎么说他们都是属于循环神经网络的一个大家族的&＃xff0c;只是在数据处理上面多了一点点东西。那么理解了RNN之后的话&＃xff0c;对于我后面理解LSTM&＃xff0c;GRU里面它的一个数据的变幻&＃xff0c;传递&＃xff0c;原理。因为后面的话&＃xff0c;我们还是要手写实现这个GRU的&＃xff08;LSTM也是一样的&＃xff0c;但是GRU少了点参数&＃xff0c;消耗的计算资源少一点点&＃xff09;。所以对于这一部分还是有必要好好唠一唠的。

首先我们来看到基本的神经网络&＃xff1a;

这是一个简单的前馈神经网络&＃xff0c;也是我们最常见的神经网络。

接下来是我们的RNN神经网络&＃xff0c;在大多数情况下&＃xff0c;我们经常会提到这几个名词&＃xff1a;时间步&＃xff0c;最后一层输出等等。

那么在这里的话&＃xff0c;我们需要理解展开的其实只有一个东西&＃xff0c;那就是对应时间步的理解&＃xff0c;什么是上一层网络的输出&＃xff0c;他们之间的参数是如何传递的。

RNN投影图

那么在此之前&＃xff0c;我们先来看看RNN的网络结构大概是什么样子的。
大多数情况下&＃xff0c;你搜索到的图片可能是这样的&＃xff1a;

首先承认这张图非常的简洁&＃xff0c;以至于你可能一开始没有反应过来&＃xff0c;什么体现循环&＃xff0c;体现时间步的地方在哪。其实这里的话&＃xff0c;这种图其实只是一个缩略平面图。

RNN是三维立体的

但是实际上&＃xff0c;如果需要用画图来表示的话&＃xff0c;RNN其实是立体的一个样子。大概长这个样子&＃xff1a;

可能有点抽象&＃xff0c;但是它的意思其实就是这样的&＃xff0c;这个其实是RNN真正的样子&＃xff0c;之后通过对不同的时间步的输出进行不同的处理&＃xff0c;最终我们还可以将RNN进行分类。

OK&＃xff0c;这个就是我们在RNN里面需要注意的点&＃xff0c;它的真实结构是这样的&＃xff0c;是一个三维度的结构。同样的接下来要提到的LSTM&＃xff0c;GRU都是。

OK&＃xff0c;接下来还没完&＃xff0c;我们现在需要不目光放长远一点&＃xff0c;首先是在RNN里面对于层的概念&＃xff0c;我们接下来会说什么什么层&＃xff0c;搭建几层的一个LSTM&＃xff0c;GRU之类的&＃xff0c;或者说几层的RNN&＃xff0c;这个层其实是指&＃xff0c;一个时间步上有几个立体的层&＃xff0c;而不是说先前平面的那种网络&＃xff0c;说几层几层。因为实际上&＃xff0c;咱们这里图画的就一层全连接&＃xff08;输入层不算&＃xff09;&＃xff0c;但是在时间步上&＃xff0c;它是N层&＃xff0c;你有几个X就有几个层。

我们拿一个句子为例&＃xff0c;假设一句话有5个单词&＃xff0c;或者说处理之后有5个词语。那么RNN就是把每一个词的词向量作为输入&＃xff0c;按照顺序&＃xff0c;按照上面图的顺序进行输入。此时需要做的就是循环5次。

LSTM&GRU

那么之后的话&＃xff0c;咱们再来说说LSTM和GRU&＃xff0c;他们呢叫做长短期记忆网络&＃xff0c;其实就是最low的RNN的一个升级版&＃xff0c;对信息进一步处理。我们对于模型的调优&＃xff0c;优化说白了&＃xff0c;除了性能的优化&＃xff0c;就是对信息的最大利用&＃xff08;增加信息&＃xff0c;或者对重点信息进行提取&＃xff09;。所以基本上为什么大模型的效果很好&＃xff0c;其实不考虑对信息的利用率&＃xff0c;单单是对信息的使用就已经达到了超大的规模&＃xff0c;这效果肯定是比小模型好一点的。

那么这里的话&＃xff0c;我们就简单过一下这个结构图吧。

首先是LSTM&＃xff0c;其实的话他这里主要是引入了一个东西&＃xff0c;叫做记忆。

c就是记忆&＃xff0c;因为刚刚的RNN&＃xff0c;的话其实更像是一个一阶的马尔科夫&＃xff0c;那么导入这个的话&＃xff0c;就相当于日记&＃xff0c;你不仅仅知道了昨天做了什么&＃xff0c;还知道了前天做了什么&＃xff0c;这样的话对于信息的利用坑定是上去了的。那么这个是它的一个单元。
宏观上还是这样的&＃xff1a;

同理GRU也是一样的

但是这里的话少了一个c 其实还是说把Ht和c合在了一起&＃xff0c;他们效果是差不多的&＃xff0c;各有各的好处&＃xff0c;你用LSTM还能多得到一个日记本&＃xff0c;用GRU的话其实相当于&＃xff0c;你把日记写在了脑子里面。好处是省钱&＃xff0c;坏处是有时候要你女朋友可能需要检查日记&＃xff08;虽然我知道你有95%以上的概率是没有的&＃xff0c;一般设置0.05 作为阈值&＃xff0c;低于这个概率&＃xff0c;基本上我们认为G了&＃xff09;

OK&＃xff0c;我们终于到了写代码的地方了&＃xff0c;首先我们这边有三个任务&＃xff0c;第一个我们要知道&＃xff0c;用户输入的想法意图是什么。所以我们这边需要搞一个文本分类的网络。之后的话&＃xff0c;我们就是对话和问答。这里比较难的其实就是闲聊部分。在这部分的话我们还需要学会如何手写GRU的循环过程&＃xff0c;为什么用GRU前面说了哈&＃xff08;省点资源&＃xff0c;也木有女朋友查“日记”的需求&＃xff0c;因为没有&＃xff09;。

分词

那么我们首先要做的就是分词
重点是为了后面能够对这两个家伙实现分词&＃xff1a;

ok,那么我们先进行分词&＃xff0c;首先是要加载咱们的词典以及咱们的这个停用词&＃xff0c;这样的话方便提高效果。
那么在这边的话在这&＃xff1a;

这里先进行初始化&＃xff0c;加载对应的词典之类的

import jieba
import jieba.posseg as pseg
from tqdm import tqdm, trange
from config.config import jieba_config
import string
jieba.load_userdict(jieba_config.get("word_dict"))
jieba &＃61; jieba
pseg &＃61; pseg
string &＃61; string
with open(file&＃61;jieba_config.get("stop_dict"),encoding&＃61;&＃39;utf-8&＃39;) as f:
lines &＃61; tqdm(f.readlines(),desc&＃61;"loading stop word")
StopWords &＃61; .fromkeys([line.rstrip() for line in lines ])
print("\\033[0;32;40m all loading is finished!\\033[0m")
__all__ &＃61; [&＃39;string&＃39;,&＃39;jieba&＃39;,&＃39;StopWords&＃39;,&＃39;pseg&＃39;]


之后的话分词就好了&＃xff1a;

"""
this model just for cutting words
"""
import utils
class Cut(object):
def __init__(self,other_letters&＃61;None):
self.letters &＃61; utils.string.ascii_letters
self.stopword &＃61; utils.StopWords
def __stop_not_sign(self,result):
result_rel &＃61; []
for res in result:
if (res not in self.stopword):
result_rel.append(res)
return result_rel
def __stop_with_sign(self, result):
result_rel &＃61; []
for res in result:
if (res.word not in self.stopword):
result_rel.append((res.word,res.flag))
return result_rel
def cut(self,sentence,by_word&＃61;False,
use_stop_word&＃61;False,with_sg&＃61;False
):
"""
:param sentence:
:param by_word:
:param use_stop_word:
:param with_sg:
:return:
"""
if(by_word):
return self.cut_sentence_by_word(sentece)
else:
&＃39;&＃39;&＃39;
without by word,so there will be cutting by jieba
&＃39;&＃39;&＃39;
if (with_sg):
result &＃61; utils.pseg.lcut(sentece)
if(use_stop_word):
result &＃61; self.__stop_with_sign(result)
else:
result &＃61; utils.jieba.lcut(sentece)
if (use_stop_word):
result &＃61; self.__stop_not_sign(result)
return result
def cut_sentence_by_word(self,sentence):
"""
it can cut English sentences and Chinese
:param sentence:
:return:
"""
result &＃61; []
temp &＃61; ""
for word in sentence:
if word.lower() in self.letters:
temp&＃43;&＃61;word
else:
if(temp!&＃61;""):
result.append(temp)
temp &＃61; ""
else:
result.append(word.strip())
if(temp!&＃61;""):
result.append(temp.lower())
return result
if __name__ &＃61;&＃61; &＃39;__main__&＃39;:
sentece &＃61; "你好呀Hello Word?"
cut &＃61; Cut()
print(cut.cut(sentece,by_word&＃61;False,use_stop_word&＃61;True,with_sg&＃61;False))


在这里的话就实现了一个简单的句子分词&＃xff0c;之后我们还需要使用到这个工具类。

FastText分类

OK&＃xff0c;我们快步进入到咱们的FastText&＃xff0c;这个东西呢&＃xff0c;其实是FaceBook推出的一个能够快速训练文本分类的一个工具模型。我们只需要按照它的格式来输入创建数据集就好了&＃xff0c;就可以实现出一个分类效果&＃xff0c;这样的话对于我们后面的作用是非常大的。

直接&＃xff1a;

pip install fasttext


即可完成安装。

那么同样的在使用之前的话&＃xff0c;我简要介绍一下FastText。

FastText网络结构

首先FastText的话其实是非常简单的一个模型

优化点

就是这样的一个结构&＃xff0c;其实和很多手写LSTM文本分类的例子很像。但是它的优化点在于&＃xff1a;
在使用方面&＃xff0c;支持并行计算&＃xff0c;可以节省训练时间。
在算法方面&＃xff1a;

1. 使用N-gram 的方式进行处理&＃xff08;当然我们这边其实也是&＃xff0c;只是我们这边N&＃61;1&＃xff09;
2. 通过哈夫曼树进行层次化softmax 优化最后计算概率

那么我们这里简单说一下这个层次化softmax。其实这玩意的本质其实就是在玩概率组合。
首先我们通过哈夫曼树&＃xff0c;将对应的标签构造出一棵树。

每次&＃xff0c;把多分类的softmax变成了二分类的&＃xff0c;此时你甚至可以直接使用sigmod代替softmax函数。

ok,这个做一个了解即可。我们继续我们的编码。

构造FastText数据集

那么接下来我们需要构建FastText需要的数据。
我们需要的数据的集合的格式是这样的&＃xff1a;

当然这个格式其实也是可以进行修改的&＃xff0c;
这个的话在fastText源码当中可以看到

那么这个的话我这里就不解释了&＃xff0c;我们直接上代码&＃xff1a;

"""
this mode for preparing data which fasttext need
"""
from tqdm import tqdm, trange
from config import config
from utils.cut_word import Cut
import json
class process_classfiy(object):
def __init__(self):
self